import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

/**
 * Created by L.jp
 * Description:
 * 有一片 n × m 大小的网格，共 n 行 m 列，其中行和列都用从 1 开始的整数编号，网格中有 k 个格子中埋有地雷。
 *  我们记第 a 行第 b 列的格子为 (a, b)。小美现在位于 (x1, y1)，她想要移动到 (x2, y2) 处。
 *  小美每次移动可以移动到与她所处格子的相邻的一格中，形式化地说，如果小美位于 (x, y)，
 *  则小美可以移动到 (x-1, y), (x+1, y), (x, y-1), (x, y+1) 的格子之一，但小美不能移动到网格之外。
 *  小美想要在移动过程中，离这些地雷越远越好，而不是走最短路径。这里定义两个格子之间的距离为曼哈顿距离，
 *  即格子 (a, b) 和 (c, d) 之间的距离是 |a-c|+|b-d|。
 *  小美想知道，移动中与地雷之间距离的最小值最大可能是多少。
 *  请注意，如果无论小美如何移动，都会进入一个有地雷的格子的话，这个最大可能值为 0。
 *  输入描述
 *  第一行三个整数 n, m, k，分别表示网格的行数，列数和地雷个数。
 *  接下来 k 行，每行两个整数 p, q，表示一个地雷放置在格子 (p, q) 中。任意两地雷的放置位置不同。
 *  接下来一行四个整数 x1, y1, x2, y2，表示小美的出发位置和目的位置。保证小美的出发位置和目的位置上没有地雷。
 *  对于全部数据，1 ≤ n, m ≤ 500, n × m ≥ 3, 1 ≤ k ≤ min{n × m-2, 400},1 ≤ p, x1, x2 ≤ n, 1 ≤ q, y1, y2 ≤ m, (x1, y1) ≠ (x2, y2)，
 *  保证 (x1, y1) 和 (x2, y2) 中没有地雷，并且一个格子中最多放置一个地雷。
 *  输出描述
 *  输出一行一个整数，表示移动过程中与地雷之间距离的最小值的可能最大值。
 *  *样例输入
 *  * 5 6 2
 *  * 2 1
 *  * 2 3
 *  * 1 1 5 1
 *  * 样例输出
 *  * 1
 * User: 86189
 * Date: 2023-04-11
 * Time: 0:03
 */
public class Main {
    static int n,m,k,x1,x2,y1,y2;
    // 定义四个方向
    static int[][] dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 输入n、m、k
        n = sc.nextInt();
        m = sc.nextInt();
        k = sc.nextInt();
        // 创建迷宫并初始化为-1
        int[][] maze = new int[n + 1][m + 1];
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                maze[i][j] = -1;
            }
        }
        Deque<int[]> dq = new LinkedList<>();
        // 将起点加入队列并将其在迷宫中的值设为0
        for (int i = 0; i < k; i++) {
            int p = sc.nextInt();
            int q = sc.nextInt();
            dq.offer(new int[]{p, q, 0});
            maze[p][q] = 0;
        }
        // 输入终点坐标
        x1 = sc.nextInt();
        y1 = sc.nextInt();
        x2 = sc.nextInt();
        y2 = sc.nextInt();
        // 广度优先搜索，计算所有点到起点的最短距离
        while (!dq.isEmpty()) {
            int[] node = dq.poll();
            int x = node[0];
            int y = node[1];
            int w = node[2];
            for (int[] dir : dirs) {
                int nx = x + dir[0];
                int ny = y + dir[1];
                if (nx < 1 || ny < 1 || nx > n || ny > m || maze[nx][ny] != -1) {
                    continue;
                }
                maze[nx][ny] = w + 1;
                dq.offer(new int[]{nx, ny, w + 1});
            }
        }
        // 二分答案，查找最小的mid使得从起点到终点的所有路径上的最小距离不小于mid
        int l = 0, r = 1000;
        while (l < r) {
            int mid = (l + r + 1) / 2;
            if (check(x1, y1, new boolean[n + 1][m + 1], maze, mid)) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }
        // 输出最终结果
        System.out.println(r);
    }
    // 深度优先搜索函数，判断从(i,j)到(x2,y2)是否存在一条路径，其上的最小距离不小于mid
    private static boolean check(int i, int j, boolean[][] vst, int[][] maze, int mid) {
        Deque<int[]> q = new LinkedList<>();
        q.offer(new int[]{i, j});
        vst[i][j] = true;
        while (!q.isEmpty()) {
            int[] node = q.poll();
            int x = node[0];
            int y = node[1];
            if (x == x2 && y == y2) {
                return true;
            }
            for (int[] dir : dirs) {
                int nx = x + dir[0];
                int ny = y + dir[1];
                if (nx < 1 || ny < 1 || nx > n || ny > m || vst[nx][ny] || maze[nx][ny] < mid) {
                    continue;
                }
                q.offer(new int[]{nx, ny});
                vst[nx][ny] = true;
            }
        }
        return false;
    }

}
